home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / escalant / escala21.lha / escalante2.1 / bin / GenericEd.C < prev    next >
C/C++ Source or Header  |  1993-07-14  |  25KB  |  1,106 lines
  1. #include "<PNAME>.h"
  2. #include "EscalanteCommands.h"
  3.  
  4. //
  5. //Language specific stuff
  6. //
  7.  
  8. #include "All<PNAME>.h"
  9. #include "<PNAME>Ids.h"
  10.  
  11.  
  12. //
  13. //You need this somewhere if you are using GridElements
  14. //This is not normally compiled in the lib 
  15. //#include "GridElement.C"
  16. //
  17.  
  18. //
  19. //Toolkit stuff
  20. //
  21.  
  22. #include "ObjList.h"
  23. #include "Buttons.h"
  24. #include "OneOfCluster.h"
  25. #include "Env.h"
  26. #include "Box.h"
  27. #include "Menu.h"
  28. #include "MenuBar.h"
  29.  
  30.  
  31. //Set these to true if you want to setup the  timer or the grid
  32.  
  33. bool gDoTimer = FALSE;
  34. bool gDoGrid = FALSE;
  35.  
  36. //
  37. //An Example of the timer ticking thru its elements
  38. //
  39. void <PNAME>Timer::Tick(){
  40. //    VGraphElement * obj;
  41. //    Iter next(elements);
  42. //    while(obj =(VGraphElement*) next()) {
  43. //        obj->Tick(); //Or some other method call
  44. //}
  45.  
  46. }
  47.  
  48.  
  49. <PNAME>Timer*     g<PNAME>Timer=0;
  50.  
  51.  
  52. //
  53. //Here we have a global pointer to a grid defined. If needed.
  54. //
  55.  
  56. #include "ObjectGrid.h"
  57. ObjectGrid *     gGrid=0;
  58.  
  59. ObjectGrid*     <PNAME>View::GetGrid(){
  60.     if(gDoGrid) return gGrid;
  61.     else return <PNAME>View_BASE::GetGrid();
  62. }
  63.  
  64.  
  65. //
  66. //Then if you have classes defined that should be put into the grid 
  67. //then overwrite the GetGrid nethod to returnthe gGrid;
  68. //
  69. //ObjectGrid * SomeClass::GetGrid(){return gGrid;}
  70. //
  71.  
  72.  
  73. //
  74. //Likewise if you want en element to be registered with a timer then do:
  75. //TimerObject* SomeClass::GetTimer(){return g<PNAME>Timer;}
  76. //
  77.  
  78.  
  79. //
  80. //Toolkit macros for setting up the meta Class stuff
  81. //
  82.  
  83. NewMetaImpl(<PNAME>,<PNAME>_BASE,(0))
  84. NewMetaImpl(<PNAME>View,<PNAME>View_BASE,(0))
  85. NewMetaImpl(<PNAME>Manager,<PNAME>Manager_BASE,(0))
  86. NewMetaImpl(<PNAME>Document,<PNAME>Document_BASE,(0))
  87.  
  88. //
  89. //Gfx ids  - Need to have any gfx id's declared here. Though if you ran Make Everything 
  90. //in  the spec editor the script, processIds, was run and should have pulled out any
  91. //ids defined and put them in <PNAME>Ids.h
  92. //
  93.  
  94. int c<PNAME>LabelId = 10000;
  95.  
  96.  
  97.  
  98.  
  99. //
  100. //There are two attributes of the base view, drawfunc and pickfunc, that 
  101. //can be set to a procedure such as the one below. This procedure determines 
  102. //whether an element can be drawn (in the case of drawfunc) or 
  103. //picked (in the case of pickfunc).
  104. //
  105. //bool <PNAME>Filter(VGraphElement * elt){
  106. //e.g.
  107. //if(elt) 
  108. //    return (elt->IsKindOf(<PNAME>Node));
  109. //return TRUE;
  110. //}
  111. //
  112.  
  113.  
  114.  
  115.  
  116.  
  117.  
  118. //
  119. //This gets called when the palette list is being created.
  120. //You can put your own tools into the palette, e.g. a delete button.
  121. //Any VObject can be put in here
  122. //The base View grabs the event and calls SetAction(vop id , (void*)vop)
  123. //The example code  creates a button marked "delete" and inserts it
  124. //at the front of the list
  125. //
  126. //void <PNAME>View::AddToToolList(ObjList *l){
  127. //
  128. //e.g.:
  129. //ActionButton * vop = new ActionButton(DELETE_ELEMENT,"Delete");
  130. //l->AddBeforePtr(vop,l->First());
  131. //}
  132. //
  133.  
  134.  
  135.  
  136. //
  137. //These methods get called when the view is looking for a tail or head
  138. //for  the VRelation nr. If FALSE then the element e is not suitable 
  139. //to be picked. If TRUE then it is ok to pick (of course another element 
  140. //may be found that is closer.)
  141. //
  142. //bool <PNAME>View::NewTailOk(VRelation* nr,VGraphElement *e){
  143. //return <PNAME>View_BASE::NewTailOk(nr,e);
  144. //}
  145. //
  146. //bool <PNAME>View::NewHeadOk(VRelation* nr,VGraphElement *e){
  147. //return <PNAME>View_BASE::NewHeadOk(nr,e);
  148. //}
  149. //
  150.  
  151.  
  152. //
  153. //This gets called when the attribute action is set to something.
  154. //You can return the name of the action. This gets displayed in the Mode: field
  155. //in the view
  156. //
  157. //char * <PNAME>View::ActionName(Actions action){
  158. //switch(action){
  159. //case <PNAME>Action1:return    " Name of <PNAME>Action1" ;
  160. //case <PNAME>Action2:return    " Name of <PNAME>Action2" ;
  161. //} 
  162. //return <PNAME>View_BASE::ActionName(action);
  163. //};
  164. //
  165.  
  166.  
  167.  
  168. //
  169. //    ***IMPORTANT****
  170. //
  171. //This method gets called when there has been menu or button input
  172. //It allow you to set the current mode variable, action, define how to pick
  173. //the object you might be looking for with SetNeed(...). Or just do something here
  174. // that doesn't require further input, e.g. hide a bunch of things, etc.
  175. //
  176.  
  177. bool <PNAME>View::SetAction2(Actions a,void * data){
  178. switch(a){
  179. case     <PNAME>StepTimer:
  180.     if(g<PNAME>Timer)     g<PNAME>Timer->Tick();
  181.     break;
  182.  
  183. case     <PNAME>ToggleTimer:
  184.     if(g<PNAME>Timer)     g<PNAME>Timer->SetActive(!g<PNAME>Timer->active);
  185.     break;
  186.  
  187. //
  188. //This file is generated by the spec editor based on menu actions defined
  189. //in the Define Menu View.
  190. //    
  191. #include "<PNAME>ActionSetAction2.h"
  192.  
  193.  
  194. //
  195. //This is a file that is generated by the spec editor and contains a bunch 
  196. //of hide element actions. It might be good to insert it into this file and 
  197. //tailor it to your needs.
  198. //
  199. #include "<PNAME>HSSetAction2.h"
  200.  
  201.  
  202. //
  203. //Here is how you can hide Gfx's with a particular ID, e.g. c<PNAME>LabelId, for all
  204. //elements currently shown.
  205. //
  206. //case  <PNAME>HideLabels:
  207. //Signature:
  208. //    void VGraphElement::SetGfxVisibility(
  209. //        int gfxid,
  210. //        bool onOrOff,
  211. //        bool doWePropagate = FALSE,
  212. //        bool prototypeListToo = FALSE,
  213. //        Object * view);
  214. //
  215. //
  216. //    vgraph->SetGfxVisibility(c<PNAME>LabelId,FALSE,  TRUE,TRUE,this);
  217. //    break;
  218. //
  219.  
  220.  
  221.  
  222. //
  223. //If a  particular action needs some element then set the variable, action, to the appropriate
  224. //action. The SetNeed method allows for the specification  of what is needed. One can specify that
  225. //an element,entity or relation is needed possibly   of a particular class. Or one can give a function
  226. //that is used to check what is being picked.
  227. //
  228. //case <PNAME>Action1:  
  229. //    action = a; 
  230. //    SetNeed([NEED_ELEMENT,NEED_ENTITY,NEED_RELATION]); OR....
  231. //    SetNeed(NEED_ELEMENT,Meta(some <PNAME> object class name));  OR...
  232. //    SetNeed(NEED_ELEMENT, some function that checks if the picked element is ok);  
  233. //    break;
  234.  
  235.  
  236.  
  237.  
  238. //
  239. //Here we don't need anything. We can apply the action directly. E.g. writing out the graph, etc.
  240. //
  241.  
  242. //case <PNAME>Action2:  
  243. //
  244. //
  245. //For example, if you want to iterate through the elements of the graph then use the VOUT macro.
  246. //This iterates on the outgoing relations of the vgraph  element. Setting elt to be the
  247. //head of the relation.
  248. //
  249. //VRelation * r;
  250. //VGraphElement * elt;
  251. //VOUT(vgraph,r,VRelation,elt,VGraphElement)
  252. //....
  253. //ENDVOUT
  254. //
  255. //You can change the class types, VRelation, VGraphElement, if you want to
  256. //limit your search to a particular type. e.g.
  257. //SomeParticularRelType * r2;
  258. //SomeParticularEltType * elt2;
  259. //VOUT(vgraph,r2,SomeParticularRelType,elt2,SomeParticularEltType)
  260. //...
  261. //ENDVOUT
  262. //break;
  263. //
  264.  
  265.  
  266.  
  267.  
  268.  
  269. default:  return <PNAME>View_BASE::SetAction2(a,data);
  270. }
  271.  
  272. return TRUE;
  273. }
  274.  
  275.  
  276. //
  277. //***IMPORTANT***
  278. //This method gets called when the left mouse  button is pushed
  279. //Here you can check the current mode you set in SetAction2. 
  280. //
  281.  
  282. Command *<PNAME>View::DoLeftButtonDownCommand(Point p, Token t, int clicks){
  283. //
  284. //The clicks arg is the number of mouse clicks. This tends to be inexact
  285. //and if there were more than 1 it could be anything. SO if you want to use
  286. //it to catch a double click the check if clicks >1 not if clicks == 2
  287. //
  288.  
  289. //
  290. //You can check if  the meta, cntl or shift keys have been pressed
  291. //
  292.  
  293. bool meta = ((t.Flags  & eFlgMetaKey) != 0);
  294. bool cntl = ((t.Flags & eFlgCntlKey) != 0);
  295. bool shift = ((t.Flags & eFlgShiftKey) != 0);
  296.  
  297.  
  298.  
  299.  
  300. VGraphElement*    pickedVGraphElement =0;
  301. VEntity*    pickedVEntity =0;
  302. VRelation*    pickedVRelation =0;
  303. Gfx*        pickedGfx =0;
  304.  
  305.  
  306. //
  307. //Here is an action include generated from the spec editor
  308. //
  309.  
  310. #include "<PNAME>ActionDoLeft.h"
  311.  
  312.  
  313.  
  314.  
  315. //
  316. //The SetNeed(NEED_ELEMENT,NEED_ENTITY,RELATION ] ,...) method defines which of the variables, 
  317. //pickedVGraphElement,pickedVEntity, or pickedVRelation ,pickedGfx gets set. 
  318. //For example if SetNeed was called as SetNeed(NEED_ENTITY,Meta(SomeClassName)) then
  319. //SatisfyNeeds  will find the nearest entity of class, SomeClassName, and set pickedVEntity 
  320. // to it.
  321. //
  322.  
  323.  
  324.  
  325. //
  326. //Here is a way to turn on(off) the Gfx visibilty for a particular  object
  327. //if(action ==     SomeGfxVisibilityAction && pickedVGraphElement){
  328. //    Command *  c = SatisfyNeeds(p,    pickedVGraphElement,pickedVEntity,  pickedVRelation ,pickedGfx);
  329. //    if(c != gNoChanges) return c;
  330. //    pickedVGraphElement->SetGfxVisibility(SomeGfxId,TRUE);
  331. //    return gNoChanges;
  332. //}
  333. //
  334.  
  335.  
  336.  
  337.  
  338. //
  339. //The following  uses of command objects to popup  windows are   moot 
  340. //if (for et3.0.alpha) you put the fix in ET++ as mentioned 
  341. //in the ESCALANTE_DIR/README file. 
  342. //
  343.  
  344. //
  345. //This is the way to show a dialog box and wait on its return.
  346. //        SomeDialog* dialog = new SomeDialog();
  347. //         int returnValue = dialog->ShowUnderMouse();
  348. //
  349.  
  350. //
  351. //To popup a new view you can do:
  352. //        gViewStack = stack;     //the stack contains the  vgraphs pushed by this  view 
  353. //                    //setting gViewStack to the EscalanteView::stack lets the new view
  354. //                    //inherit this views stack
  355. //        EscalanteDocument * newdoc = gEscalanteManager->NewEscalanteDocument(some visual graph element);
  356. //        gViewStack =0;
  357. //        if(newdoc) newdoc->Show();
  358.  
  359.  
  360.  
  361.  
  362.  
  363. return <PNAME>View_BASE::DoLeftButtonDownCommand(p,  t, clicks);
  364.  
  365.  
  366. }
  367.  
  368.  
  369.  
  370. //
  371. //This is just like DoLeftButtonDowmCommand
  372. //
  373.  
  374. Command *<PNAME>View::DoMiddleButtonDownCommand(Point p, Token t, int i){
  375. //bool meta = ((t.Flags  & eFlgMetaKey) != 0);
  376. //bool cntl = ((t.Flags & eFlgCntlKey) != 0);
  377. //bool shift = ((t.Flags & eFlgShiftKey) != 0);
  378.  
  379.  
  380. VGraphElement * pickedVGraphElement =0;
  381. VEntity*    pickedVEntity =0;
  382. VRelation*    pickedVRelation =0;
  383. Gfx *         pickedGfx =0;
  384.  
  385.  
  386. #include "<PNAME>ActionDoMiddle.h"
  387.  
  388. return <PNAME>View_BASE::DoMiddleButtonDownCommand(p,  t, i);
  389. }
  390.  
  391.  
  392.  
  393.  
  394.  
  395.  
  396. //
  397. //This method gets called after the pick rectangle has been drawn.
  398. //The rectangle is the BaseEscalanteView attribute selectionRect
  399. //
  400. //void <PNAME>View::DoneDrawingRect(){
  401. //<PNAME>View_BASE::DoneDrawingRect();
  402. //}
  403. //
  404.  
  405.  
  406. //
  407. //This method gets called after an element has been added.
  408. //
  409. //void <PNAME>View::DoneAddingElement(VGraphElement*e){
  410. //<PNAME>View_BASE::DoneAddingElement(e);
  411. //}
  412. //
  413.  
  414. //
  415. //This method gets called after a bunch off  elements have been added.
  416. //e.g. using multiple add
  417. //
  418. //void        <PNAME>View::DoneAddingElements(class Set*s){}
  419. //
  420.  
  421.  
  422. //
  423. //This method gets called after the position of an element has been moved
  424. //
  425. //void    <PNAME>View::DoneMovingElement(VGraphElement*e){}
  426. //
  427.  
  428.  
  429. //
  430. //This method gets called before an element is deleted.
  431. //If return is FALSE then the delete does not occur
  432. //
  433. //bool <PNAME>View::OkToDeleteElement(VGraphElement*e){
  434. //return <PNAME>View_BASE::OkToDeleteElement(e);
  435. //}
  436. //
  437.  
  438.  
  439.  
  440.  
  441.  
  442. //
  443. //These methods are called when the View is drawn and when the graph
  444. //is drawn.
  445. //
  446. //void <PNAME>View::Draw(Rectangle){}
  447. //void <PNAME>View::DrawGraph(Rectangle r){}
  448. //
  449.  
  450.  
  451.  
  452. //
  453. //This  methoid gets called when a new graph object has been picked
  454. //(e.g. using Old View/New Graph).  vg is  the object that has been
  455. //picked. Newvg  is a  parameter that is set to whatever new graph
  456. //is desired. The default is newvg =vg;
  457. //
  458. //void <PNAME>View::GetNewGraph(VGraphElement *  vg,VGraphElement * & newvg){}
  459. //
  460.  
  461.  
  462.  
  463. //
  464. //This gets called when a new graph has been picked. The base classes
  465. //do things like calling GetNewGraph, MakeToolList, etc.
  466. //For instance,  look at the specification view GrandView::NewGraph. 
  467. //Here we do some of our own things. The BaseEscalanteView::type attribute
  468. //is used to determine what type the view is. The GrandView sets its
  469. //drawfunc accordingly and changes the name of its window.
  470. //
  471. //You can do whatever it is you want to do.
  472. //
  473. //void <PNAME>View::NewGraph(VGraphElement *, bool push = FALSE){}
  474. //
  475.  
  476.  
  477.  
  478.  
  479. //
  480. //These methods get called when the head(or tail) of a relation cannot be found  
  481. //The Set,s, is the set of VGraphElements that may have been added along with 
  482. //the relation r (the relation is in the set s)
  483. //If the return is eAbort then the adding of the relation is aborted 
  484. //without any of the elements just created being added to the graph.
  485. //It is up to these methods to determine what to do with the relation (e.g. deleting).
  486. //the elements in the set s. 
  487. //If the return is eAbortButSaveElements then the add is aborted but any elements in the
  488. //set s are added to the graph
  489. //If the return is eContinue then the process  just continues.  
  490.  
  491. //
  492. //ErrorReturn <PNAME>View::CouldNotFindHead(VRelation*r,Set *s ){
  493. //return <PNAME>View_BASE::CouldNotFindHead(r);
  494. //}
  495. //
  496. //ErrorReturn <PNAME>View::CouldNotFindTail(VRelation*r,Set * s){
  497. //return <PNAME>View_BASE::CouldNotFindTail(r);
  498. //}
  499. //
  500.  
  501.  
  502.  
  503.  
  504.  
  505. //
  506. //This method gets called when some activity occurs  in a VObject
  507. //that is contained by this view. e.g  picking an element in the palette
  508. //
  509. //void <PNAME>View::Control(int id, int part, void *val){
  510. //<PNAME>View_BASE::Control(id,part,val);
  511. //}
  512. //
  513.  
  514.  
  515. //
  516. //This method gets called when some activity occurs  in a VObject
  517. //that the view creates. e.g. buttons, fields, etc.
  518. //
  519. //void <PNAME>Document::Control(int id, int part, void *val){
  520. //<PNAME>Document_BASE::Control(id,part,val);
  521. //}
  522. //
  523.  
  524.  
  525.  
  526. //
  527. // *** IMPORTANT ****
  528. //
  529. //This is where you define the initial system architecture.
  530. //For each of the following vgraph[123] added to the list vgs 
  531. //(of course you can have any number of vgraphs and windows)
  532. //there will  be a  window created. By letting the vgraphs
  533. //share a common sg changes to one vgraph can be propagated
  534. //to the others.  E.g. Multiple views of a  common structure. 
  535. //See the example application ESCALANTE_DIR/apps/MView.
  536. //Of course you don't have to have an sg.
  537. //
  538.  
  539. VGraphElement * gVGraph1 = 0;
  540. VGraphElement * gVGraph2 = 0;
  541. VGraphElement * gVGraph3 = 0;
  542.  
  543.  
  544.  
  545.  
  546.  
  547. void <PNAME>::MakeGraph(SGraphElement* & sg, ObjList* & vgs){
  548. if(vgs == 0) vgs = new ObjList();
  549.  
  550. VGraphElement *ve;
  551. SGraphElement *se;
  552. VRelation * vr;
  553.  
  554.  
  555.  
  556. gVGraph1 = new VGraphElement(); gVGraph1->Init(); 
  557. //gVGraph2 = new VGraphElement(); gVGraph2->Init();
  558. //gVGraph3 = new VGraphElement(); gVGraph3->Init();
  559.  
  560.  
  561.  
  562. //
  563. //You can set compile flags so that structural graph elements
  564. //are not used. That is why we have the following #ifdef
  565. //
  566.  
  567. #ifdef USE_STRUCTURAL
  568.  
  569. //sg = new SGraphElement(); sg->Init();
  570.  
  571. //sg->AddVGelt(gVGraph1); 
  572. //sg->AddVGelt(gVGraph2); 
  573. //sg->AddVGelt(gVGraph3);
  574.  
  575. //gVGraph1->SetSGelt(sg);
  576. //gVGraph2->SetSGelt(sg); 
  577. //gVGraph3->SetSGelt(sg);
  578. #endif
  579.  
  580. if(gVGraph1)
  581.     vgs->Add(gVGraph1);
  582. if(gVGraph2)
  583.     vgs->Add(gVGraph2);
  584. if(gVGraph3)
  585.     vgs->Add(gVGraph3);
  586.  
  587.  
  588. //
  589. //This is where you define the objects you want shown in the palette
  590. //
  591.  
  592.  
  593. //
  594. //The following  file gets generated automatically when you do a Make Everything in the
  595. //specification editor. The default is that  all visual constructs that were specified
  596. //are included in this list. No structural elements are added here.
  597. //
  598.  
  599. #include "<PNAME>MakeGraph.h"
  600.  
  601.  
  602.  
  603. //
  604. //Use ADDV(...) when you do not want a structural element associated with the visual element
  605. //This makes IO much quicker, there are less things to read and write
  606. //
  607. //ADDV(Some <PNAME> element class,gVGraph1);
  608. //
  609.  
  610.  
  611. //
  612. //ADDSV(Some Structural entity class ,Some <PNAME> entity class,gVGraph1);
  613. //ADDSV(Some structural relation class,Some <PNAME> relation, class,gVGraph1);
  614. //
  615.  
  616.  
  617.  
  618.  
  619. //
  620. //Here you can add elements to gVGraph2. This will cause a second view window
  621. //to open. If the structural types used here  are the same as defined for gVGraph1
  622. //things then when you add an element to gVGraph2 it is also added to gVGraph1 
  623. //(and vice versa)
  624. //
  625. //ADDSV(Some Structural entity class,Some <PNAME> entity,gVGraph2);
  626. //ADDSV(SRelation,Some <PNAME> relation,gVGraph2);
  627. //
  628.  
  629.  
  630.  
  631. //Here are some more flags you can set for the elements you are adding
  632. //to the proto list
  633.  
  634.  
  635. //
  636. //If you don't want an element you just added to the protos list
  637. //to show up in the palette then do:
  638. //ve->ShowInPalette(FALSE);
  639. //
  640.  
  641.  
  642. //
  643. //On adding an entity to a view the default is to just plop down the entity
  644. //If you want a bunch of joints added or the point P2 to be set (e.g. sweeping out
  645. //an area) then set the following flag. 
  646. //ve->NeedJoints(TRUE);
  647. //
  648.  
  649.  
  650. //
  651. //If there are other vgraphelements associated with this element and we do not
  652. //want to change the postiion of this element when the positions of all of the 
  653. //connected elements is changed (via meta key or All... methods then set this flag  
  654. //
  655. //ve->AcceptPosChange(FALSE);
  656.  
  657.  
  658.  
  659.  
  660. //
  661. //When writing out this object is theimage also written out.
  662. //Normally it isn't. IO seems to be quicker that way.
  663. //Of course you can't   save any state that has changes in the Gfx's
  664. //So if you want the image to be saved for this element then set:
  665. //
  666. //ve->WriteGfx(TRUE);
  667. //
  668.  
  669.  
  670. //
  671. //Are the joints that this element  has  relative to the point p1
  672. //
  673. //ve->RelJoints(TRUE);
  674. //
  675.  
  676.  
  677.  
  678.  
  679. //
  680. //If this element is in a prototype list can it be used as a prototype
  681. //when we get a NewElement from a connected SGraphElement. 
  682. //The default is TRUE
  683. //
  684. //ve->AcceptMapping(FALSE);
  685. //
  686.  
  687.  
  688.  
  689.  
  690.  
  691. //
  692. //While we are here there are also a bunch of virtual methods in VGraphElement 
  693. //that you can override that determine some of the behavior of the elements
  694. //
  695.  
  696. //
  697. //How small can the element be
  698. //
  699. //Point GetMinExtent(){return Point(20,20);}
  700. //
  701.  
  702.  
  703. //
  704. //What is the name of the icon for this  element
  705. //
  706. //char * GetIconName(){return 0;}
  707. //
  708.  
  709. //When the element has been moved this method is called
  710. //void MS_Moved(){}
  711. //
  712.  
  713.  
  714. //
  715. //A hook for drawing
  716. //
  717. //virtual bool MS_Draw(Rectangle,void *){return TRUE;}
  718. //
  719.  
  720. //
  721. //And there are others. Just look in VGraphElement.h,VRelation.h,
  722. //PVGraphElement.h and GraphObject.h
  723. //
  724.  
  725. } 
  726.  
  727.  
  728.  
  729. //
  730. //These methods are called to make the manager,document and views of the appropriate
  731. //type. A system is composed of one Manager, gEscalanteManager. That manager contains
  732. //any number of Document  objects. (one document for each window shown). Each Document
  733. //has any number of Views (The default is one View per Documenet. However, you can 
  734. //set a flag in ETRC to show an observer view.)  
  735. //So we have something like this:
  736. //
  737. //                        gEscalanteManager
  738. //                       /   | ...   \
  739. //                      /    |  ...   \
  740. //                   Doc    Doc  ...   Doc
  741. //                  / \      |    ...    \
  742. //             View ...View  View  ...    View
  743. //
  744. //
  745. //You can have other types of documents in the system. Look at the PaletteDocument
  746. //object in  Escalante.[Ch].
  747. //
  748. //
  749. //The default behavior is the following:
  750. //The Application, <PNAME> creates a Manager  of type <PNAME>Manager.
  751. //The manager creates a document for each element in the vgraphs list created
  752. //in <PNAME>::MakeGraph(). The Manager calls the virtual method MakeEscalanteDocument
  753. //which by default returns a <PNAME>Document. This document calls the method MakeEscalanteView
  754. //which by default returns a <PNAME>View.
  755. //
  756.  
  757.  
  758. EscalanteView * <PNAME>Document::MakeEscalanteView(int id,    
  759.     Point p,    
  760.     VGraphElement *vg){
  761.         return  new <PNAME>View(id,this,p,vg);    
  762. }
  763.  
  764.  
  765.  
  766.  
  767.  
  768.  
  769.  
  770.  
  771.  
  772. EscalanteDocument * <PNAME>Manager::MakeEscalanteDocument(VGraphElement *vg){
  773. return new <PNAME>Document(vg);
  774. }
  775.  
  776. EscalanteManager * <PNAME>::MakeEscalanteManager(SGraphElement * sg,ObjList * vgs){
  777. return new <PNAME>Manager(sg,vgs);
  778. }
  779.  
  780.  
  781.  
  782.  
  783. void <PNAME>Document::DoSetupMenu(Menu* m ){
  784. register EscalanteView * dv; 
  785. Iter next(views);
  786. int id = m->GetId();
  787.  
  788. if(id == e<PNAME>MENU  || id == e<PNAME>HideMenu) {
  789.     while(dv = (EscalanteView*)next()) 
  790.         if( dv != gFirstHandler)
  791.             dv->DoSetupMenu(m);
  792. }
  793. else <PNAME>Document_BASE::DoSetupMenu(m);
  794. }
  795.  
  796. //
  797. //This is where the menus are initially created
  798. //
  799.  
  800. MenuBar *<PNAME>Document::DoMakeMenuBar(){
  801. MenuBar * mb;
  802.  
  803. //
  804. //If you want to not have the default menus created in the base classes
  805. //then don't call the parent class DoMakeMenuBar.
  806. //Make your own menu bar and set up the menus as you want them
  807. // 
  808.  
  809. mb=  <PNAME>Document_BASE::DoMakeMenuBar();
  810. if(!mb) return 0;
  811.  
  812.  
  813. Menu * m;
  814. m = <PNAME>View::MakeMenu(e<PNAME>MENU);
  815. if(m){
  816.     m->SetName("<PNAME>");
  817.     mb->AddMenu(m);
  818. }
  819.  
  820. m = <PNAME>View::MakeMenu(e<PNAME>HideMenu);
  821. if(m){
  822.     m->SetName("Hide/Show");
  823.     mb->AddMenu(m);
  824. }
  825. return mb;
  826. }
  827.  
  828.  
  829.  
  830.  
  831.  
  832.  
  833. <PNAME>View::<PNAME>View(int id,
  834.     class Document* doc,
  835.     Point pt,
  836.     VGraphElement*vg,
  837.     bool makePalette):<PNAME>View_BASE(id,doc,pt,vg,makePalette){
  838.     if(gDoGrid){
  839.         Multiples(TRUE);
  840.         DoGrid(TRUE);
  841.     }
  842. }
  843.  
  844.  
  845.  
  846. Menu* <PNAME>View::MakeMenu(int menuid){
  847. Menu *menu=0; 
  848. Menu * m;
  849. switch(menuid){
  850.  
  851. case e<PNAME>MENU:
  852.     menu =  new Menu(menuid,FALSE);
  853.     menu->SetName("<PNAME>");
  854.     if(gDoTimer)
  855.         menu->AppendItems(
  856.              "Step Clock",<PNAME>StepTimer, 
  857.             "Toggle Clock@C",<PNAME>ToggleTimer, 0);
  858.  
  859.  
  860.     menu->AppendItems(
  861. //
  862. //Here is the include file generated   by GrandView  
  863. //
  864.  
  865. #include "<PNAME>ActionMakeMenu.h"
  866.             0);        
  867.  
  868. //
  869. //This is how you can make a pull right menu
  870. // 
  871. //    m = MakeMenu(ePullRightMenu);
  872. //    if(m) menu->AppendMenu(m,ePullRightMenu);
  873.  
  874.     break;
  875.  
  876.  
  877.  
  878. case e<PNAME>HideMenu:
  879.     menu =  new Menu(menuid,FALSE);
  880.     menu->SetName("Hide/Show");
  881. //
  882. //This is the hide/show menu generated by GrandView
  883. // 
  884.  
  885.     menu->AppendItems(
  886.         #include "<PNAME>HSList.h"    
  887.         0);        
  888.  
  889.  
  890.     break;
  891.  
  892. case ePullRightMenu:
  893.     menu =  new Menu(menuid,FALSE);
  894.     menu->SetName("Pull right");
  895.     menu->AppendItems(
  896.             "Action 3" ,<PNAME>Action3,
  897.             0);        
  898.  
  899.     break;
  900.  
  901. default: return EscalanteView::MakeMenu(menuid);
  902. }
  903. return menu;
  904. }    
  905.  
  906. //
  907. //DoSetupMenu gets called every time a menu is pulled down. 
  908. //This is where you enable the menu items and/or change what is
  909. //displayed
  910. //
  911.  
  912. void <PNAME>View::DoSetupMenu(Menu *menu){
  913.     Menu * omenu;
  914.     switch(menu->GetId()){
  915.     case ePullRightMenu:
  916.         menu->EnableItems(<PNAME>Action3,0);
  917.         break;
  918.  
  919.     case e<PNAME>HideMenu:
  920.         #include "<PNAME>HSEnable.h"    
  921.  
  922.         break;
  923.  
  924.     case e<PNAME>MENU:
  925. //
  926. //If there is a pull right menu defined in e<PNAME>MENU then do the following 
  927. //
  928.         if(omenu = (Menu*) menu->FindMenuItem(ePullRightMenu))
  929.             omenu->SetNextHandler(this);
  930.  
  931. //
  932. //Here is an action include
  933. //
  934.  
  935. #include "<PNAME>ActionEnableMenu.h"
  936.  
  937.  
  938.  
  939.  
  940. //
  941. //The following enables the items in e<PNAME>MENU
  942. //
  943.     if(gDoTimer && g<PNAME>Timer){
  944.         menu->EnableItems(<PNAME>StepTimer, <PNAME>ToggleTimer,0);
  945.         menu->ReplaceItem(<PNAME>ToggleTimer,g<PNAME>Timer->active? "Clock Off@C":"Clock On@C");
  946.     }
  947.  
  948.  
  949.         break;
  950.  
  951.     default: <PNAME>View_BASE::DoSetupMenu(menu);
  952. }
  953. }
  954.  
  955.  
  956.  
  957. //
  958. //This method allows you to overwrite completely how the view is set up
  959. //e.g. palette, canvas , topvobj, bottomvobj, etc.
  960. //
  961. //VObject * <PNAME>View::GetView(){
  962. //return <PNAME>View_BASE::GetView();
  963. //}
  964. //
  965.  
  966.  
  967.  
  968. //
  969. //This method allows you to return a VObject that will be displayed under the
  970. //menu bar and over the canvas/palette. (where the Mode:  and Error: fields is now.
  971. //You can incorporate the Mode: and Error: fields. They are  EscalanteView::info and EscalanteView::error
  972. //
  973. //VObject * <PNAME>View::GetTopVObj(){
  974. //return <PNAME>View_BASE::GetTopVObj();
  975. //}
  976. //
  977.  
  978.  
  979. //
  980. //This method returns a vobject that is displayed under the palette/view area
  981. //
  982. //VObject * <PNAME>View::GetBottomVObj(){
  983. //return <PNAME>View_BASE::GetBottomVObj();
  984. //}
  985. //
  986.  
  987.  
  988.  
  989.  
  990. //
  991. //These methods allow you to return a  string that provides a description of
  992. //this view, an element or an action.
  993. //
  994. //char * <PNAME>View::GetDescription(){
  995. //return <PNAME>View_BASE::GetDescription();
  996. //}
  997. //
  998. //char * <PNAME>View::GetElementDescription(VGraphElement*e){
  999. //return <PNAME>View_BASE::GetElementDescription(e);
  1000. //}
  1001. //
  1002. //char * <PNAME>View::GetActionDescription(Actions a){
  1003. //return <PNAME>View_BASE::GetActionDescription(a);
  1004. //}
  1005. //
  1006.  
  1007.  
  1008. //
  1009. //These methods allow you to override how errors are signaled and cleared.
  1010. //
  1011. //void <PNAME>View::SignalError(char * c){
  1012. //<PNAME>View_BASE::SignalError(c);
  1013. //}
  1014. //
  1015. //void <PNAME>View::ClearError(){
  1016. //<PNAME>View_BASE::ClearError();
  1017. //}
  1018. //
  1019.  
  1020.  
  1021.  
  1022. //
  1023. //These methods allow you to override how modes are signaled and cleared.
  1024. //
  1025.  
  1026. //void <PNAME>View::SignalMode(char * c){
  1027. //<PNAME>View_BASE::SignalMode(c);
  1028. //}
  1029. //    
  1030. //void <PNAME>View::ClearMode(){
  1031. //<PNAME>View_BASE::ClearMode();
  1032. //}
  1033. //
  1034.  
  1035.  
  1036.  
  1037.  
  1038.  
  1039.  
  1040. <PNAME>::<PNAME>(int argc, char* * argv):<PNAME>_BASE(argc,argv){
  1041. //
  1042. //If you want to set some global variables fronm the ETRC this is a good place
  1043. //to do it.
  1044. //E.g. 
  1045. //SomeGlobalVariable = Env::GetValue("Some.Name.In.The.ETRC.File", some default value);
  1046. //
  1047.  
  1048.  
  1049. //
  1050. //This creates a new timer object. active = FALSE; rate = 0; (fastest)
  1051. //
  1052. if(gDoTimer)
  1053.     g<PNAME>Timer= new <PNAME>Timer(FALSE,0);
  1054.     
  1055.  
  1056. //
  1057. //This creates a new grid object if needed
  1058. //
  1059.  
  1060. if(gDoGrid)
  1061.     gGrid= new  ObjectGrid(gGridSize);
  1062. }
  1063.  
  1064.  
  1065. main(int argc, char **argv){
  1066. //
  1067. //If you want to preload bitmap files for performance do:
  1068. //FindBitmap("some bitmap file name");
  1069. //This finds the bitmap and loads it into a global bitmap
  1070. //list. When a BitmapGfx  object is created it looks at the list.
  1071. //This speeds up the process. 
  1072. //
  1073.  
  1074.  
  1075.  
  1076. //You can define a color mapping using the gColorMap.
  1077. //This maps an integer to a color and is used in the Gfx attribute mapping
  1078. //e.g.
  1079. //gColorMap[1] = eRed;
  1080. //
  1081.  
  1082.  
  1083. //
  1084. //Likewise you can use a global text map that maps 
  1085. //an integer to a text string
  1086. //e.g.
  1087. //gTextMap[1] = "Some text string";
  1088. // 
  1089.  
  1090.  
  1091.  
  1092.     gBorder = gPoint0;
  1093.     DoGlobalInits();
  1094.  
  1095.     <PNAME> theApplication(argc, argv);
  1096.     return theApplication.Run();
  1097. }
  1098.  
  1099.  
  1100.  
  1101.  
  1102.  
  1103.  
  1104.  
  1105.  
  1106.